package pl.wroc.pwr.psi.service;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.TreeMap;
import java.util.List;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import pl.wroc.pwr.psi.entity.Opcja;
import pl.wroc.pwr.psi.entity.PytanieOtwarte;
import pl.wroc.pwr.psi.entity.PytanieOtwarteToSzablon;
import pl.wroc.pwr.psi.entity.PytanieToSzablon;
import pl.wroc.pwr.psi.entity.PytanieZamkniete;
import pl.wroc.pwr.psi.entity.PytanieZamknieteToSzablon;
import pl.wroc.pwr.psi.entity.Szablon;
import pl.wroc.pwr.psi.repository.OpcjaRepository;
import pl.wroc.pwr.psi.repository.PytanieOtwarteRepository;
import pl.wroc.pwr.psi.repository.PytanieOtwarteToSzablonRepository;
import pl.wroc.pwr.psi.repository.PytanieToSzablonRepository;
import pl.wroc.pwr.psi.repository.PytanieZamknieteRepository;
import pl.wroc.pwr.psi.repository.PytanieZamknieteToSzablonRepository;
import pl.wroc.pwr.psi.repository.SzablonRepository;

@Service
public class TworzenieSzablonuService {

	@Autowired
	private SzablonRepository szablonRepository;

	@Autowired
	private PytanieZamknieteRepository pytanieZamknieteRepository;

	@Autowired
	private PytanieOtwarteRepository pytanieOtwarteRepository;

	@Autowired
	private PytanieToSzablonRepository pytanieToSzablonRepository;

	@Autowired
	private PytanieZamknieteToSzablonRepository pytanieZamknieteToSzablonRepository;

	@Autowired
	private PytanieOtwarteToSzablonRepository pytanieOtwarteToSzablonRepository;

	@Autowired
	private OpcjaRepository opcjaRepository;

	public int dodajSzablon(String nazwa) {
		Szablon szablon = new Szablon();
		szablon.setNazwa(nazwa);
		szablonRepository.save(szablon);
		return szablon.getId();
	}

	public Szablon findSzablonById(int id) {
		return szablonRepository.findOne(id);
	}
	
	public Szablon findSzablonByName(String name) {
		Szablon sz = new Szablon();		
		List<Szablon> szablony = szablonRepository.findAll();

		for(Szablon szablon: szablony){
			if(szablon.getNazwa().equals(name)){
				sz= szablon;
			}
		}
		return sz;
	}

	public PytanieZamkniete findPytanieZamknieteById(int id) {
		return pytanieZamknieteRepository.findOne(id);
	}

	public PytanieOtwarte findPytanieOtwarteById(int id) {
		return pytanieOtwarteRepository.findOne(id);
	}
	
	public PytanieOtwarteToSzablon findPytanieOtwarteFromSzablon(int idSzablonu, int idPytania) {

		Set<PytanieOtwarteToSzablon> pytania = szablonRepository.findOne(
				idSzablonu).getPytaniaOtwarte();
		
		PytanieOtwarteToSzablon pots =new PytanieOtwarteToSzablon();

		for (PytanieOtwarteToSzablon pytanie : pytania) {

			if(pytanie.getSzablon().getId().intValue()==idSzablonu && pytanie.getPytanieOtwarte().getId().intValue()==idPytania){
				pots = pytanie;
			}
		}

		return pots;
	}
	
	public PytanieZamknieteToSzablon findPytanieZamknieteFromSzablon(int idSzablonu, int idPytania) {

		Set<PytanieZamknieteToSzablon> pytania = szablonRepository.findOne(
				idSzablonu).getPytaniaZamkniete();
		
		PytanieZamknieteToSzablon pzts =new PytanieZamknieteToSzablon();

		for (PytanieZamknieteToSzablon pytanie : pytania) {

			if(pytanie.getSzablon().getId().intValue()==idSzablonu && pytanie.getPytanieZamkniete().getId().intValue()==idPytania){
				pzts = pytanie;
			}
		}

		return pzts;
	}

	public void dodajPytanieZamknieteDoSzablonu(int pytanieId,
			int szablonId) {
		Szablon szablon = findSzablonById(szablonId);
		PytanieZamkniete pytanieZamkniete = findPytanieZamknieteById(pytanieId);
		PytanieZamknieteToSzablon pzts = new PytanieZamknieteToSzablon();
		pzts.setSzablon(szablon);
		pzts.setPytanieZamkniete(pytanieZamkniete);
		pytanieZamknieteToSzablonRepository.save(pzts);
		PytanieToSzablon pts = new PytanieToSzablon();
		pts.setSzablon(szablon);
		pts.setPytanieZamkniete(pytanieZamkniete);
		pytanieToSzablonRepository.save(pts);
	}

	public void dodajPytanieOtwarteDoSzablonu(int pytanieId,
			int szablonId) {
		Szablon szablon = findSzablonById(szablonId);
		PytanieOtwarte pytanieOtwarte = findPytanieOtwarteById(pytanieId);
		PytanieOtwarteToSzablon pots = new PytanieOtwarteToSzablon();
		pots.setSzablon(szablon);
		pots.setPytanieOtwarte(pytanieOtwarte);
		pytanieOtwarteToSzablonRepository.save(pots);
		PytanieToSzablon pts = new PytanieToSzablon();
		pts.setSzablon(szablon);
		pts.setPytanieOtwarte(pytanieOtwarte);
		pytanieToSzablonRepository.save(pts);
	}

	public int dodajPytanieZamkniete(String tresc) {
		PytanieZamkniete pytanie = new PytanieZamkniete();
		pytanie.setTresc(tresc);
		pytanieZamknieteRepository.save(pytanie);
		return pytanie.getId();
	}

	public int dodajPytanieOtwarte(String tresc) {
		PytanieOtwarte pytanie = new PytanieOtwarte();
		pytanie.setTresc(tresc);
		pytanieOtwarteRepository.save(pytanie);
		return pytanie.getId();
	}

	public void dodajOpcje(int pytanieZamknieteId, String[] opcje) {
		PytanieZamkniete pytanieZamkniete = (PytanieZamkniete) findPytanieZamknieteById(pytanieZamknieteId);
		pytanieZamknieteRepository.save(pytanieZamkniete);
		Opcja opcja;
		Set<Opcja> opcjeSet = new HashSet<Opcja>();
		for (String tresc : opcje) {
			opcja = new Opcja();
			opcja.setTresc(tresc);
			opcjeSet.add(opcja);
		}

		for (Opcja op : opcjeSet) {
			op.setPytanieZamkniete(pytanieZamkniete);
			opcjaRepository.save(op);

		}
		pytanieZamkniete.setOpcjas(opcjeSet);
		pytanieZamknieteRepository.save(pytanieZamkniete);
	}

	public void usunPytanieZamknieteById(int idPytania) {
		pytanieZamknieteRepository.delete(idPytania);
	}
	
	public void usunPytanieOtwarteById(int id) {
		pytanieOtwarteRepository.delete(id);
	}
	
	public void usunPytanieOtwarteToSzablonById(int idSzablonu, int idPytania) {
		pytanieOtwarteToSzablonRepository.delete(findPytanieOtwarteFromSzablon(idSzablonu, idPytania).getId());
	}
	
	public void usunPytanieZamknieteToSzablonById(int idSzablonu, int idPytania) {
		pytanieZamknieteToSzablonRepository.delete(findPytanieZamknieteFromSzablon(idSzablonu, idPytania).getId());
	}

	public void usunPytanieZamkniete(int idPytania, int idSzablonu,int numerPytaniaToSzablon) {
		usunPytanieZamknieteToSzablonById(idSzablonu, idPytania);
		usunPytanieToSzablonById(numerPytaniaToSzablon);
		usunPytanieZamknieteById(idPytania);		
	}
	
	public void usunPytanieOtwarte(int idPytania, int idSzablonu, int numerPytaniaToSzablon) {
		usunPytanieOtwarteToSzablonById(idSzablonu, idPytania);
		usunPytanieToSzablonById(numerPytaniaToSzablon);
		usunPytanieOtwarteById(idPytania);
	}

	public List<PytanieZamkniete> findAllPytanieZamkniete() {
		return pytanieZamknieteRepository.findAll();
	}

	public List<Szablon> findAllSzablon() {
		return szablonRepository.findAll();
	}
	
	public List<String> findAllSzablonNames() {
		
		List<String> szablonNames = new ArrayList<String>();
		for(Szablon szablon : szablonRepository.findAll())
		{
			szablonNames.add(szablon.getNazwa());
		}
		return szablonNames;
	}
	
	public TreeMap<Integer,String> findIdPytanFromSzablon(int idSzablonu) {

		TreeMap<Integer,String> idPytan = new TreeMap<Integer,String>();
				
		List<PytanieToSzablon> pytania = pytanieToSzablonRepository.findAll();

		for(PytanieToSzablon pytanie:pytania){
			int aktualneIdSzablonu = pytanie.getSzablon().getId().intValue();
			if(aktualneIdSzablonu==idSzablonu){
				
				if(pytanie.getPytanieOtwarte()!=null){
					idPytan.put(pytanie.getPytanieOtwarte().getId(),"otwarte");
				}
				else
				{ 
					if(pytanie.getPytanieZamkniete()!=null)
					{
						idPytan.put(pytanie.getPytanieZamkniete().getId(),"zamkniete");
					}
				}				
			}
		}
		return idPytan;
	}

	public Set<PytanieZamkniete> findPytaniaZamknieteFromSzablon(int idSzablonu) {

		Set<PytanieZamknieteToSzablon> pytania = szablonRepository.findOne(
				idSzablonu).getPytaniaZamkniete();
		Set<PytanieZamkniete> pytaniaZamkniete = new HashSet<PytanieZamkniete>();

		for (PytanieZamknieteToSzablon pytanie : pytania) {

			pytaniaZamkniete.add(pytanie.getPytanieZamkniete());
		}

		return pytaniaZamkniete;
	}

	public Set<PytanieOtwarte> findPytaniaOtwarteFromSzablon(int idSzablonu) {

		Set<PytanieOtwarteToSzablon> pytania = szablonRepository.findOne(
				idSzablonu).getPytaniaOtwarte();
		Set<PytanieOtwarte> pytaniaOtwarte = new HashSet<PytanieOtwarte>();

		for (PytanieOtwarteToSzablon pytanie : pytania) {

			pytaniaOtwarte.add(pytanie.getPytanieOtwarte());
		}

		return pytaniaOtwarte;
	}

	public void usunSzablonById(int id) {
		szablonRepository.delete(id);
	}

	public int findOstatniNumerPytaniaWSzablonie(int szablonId) {
		List<PytanieToSzablon> pytania = pytanieToSzablonRepository.findAll();
		
		int max=0;
		
		for(PytanieToSzablon pytanie:pytania){
			int aktualneIdSzablonu = pytanie.getSzablon().getId().intValue();
			if(aktualneIdSzablonu==szablonId){
				
				max++;
			}
		}
		
		return max;
	}
	
	public int findNumerPytaniaWSzablonie(int szablonId, int pytanieId) {
		List<PytanieToSzablon> pytania = pytanieToSzablonRepository.findAll();
		
		int numer=0;
		
		for(PytanieToSzablon pytanie:pytania){
			int aktualneIdSzablonu = pytanie.getSzablon().getId().intValue();
			if(aktualneIdSzablonu==szablonId){
				
				numer++;
				if(pytanie.getPytanieOtwarte()!=null){
					if(pytanie.getPytanieOtwarte().getId().intValue()==pytanieId){
						
						return numer;
					}
				}
				else{
					if(pytanie.getPytanieZamkniete().getId().intValue()==pytanieId){
						
						return numer;
					}
				}
			}
		}		
		return numer;
	}
	public int findMaxLiczbaOpcji(Set<PytanieZamkniete> pytaniaZamkniete) {
		
		int maxLiczbaOpcji = 1;
		
		for(PytanieZamkniete pytanie : pytaniaZamkniete)
		{
			
			int liczbaOpcji = 0;
			for(Opcja opcja : pytanie.getOpcjas())
			{
				String[] opcje = opcja.getTresc().split(",");
				liczbaOpcji = opcje.length;
			}
			if(maxLiczbaOpcji<liczbaOpcji)
			{
				maxLiczbaOpcji = liczbaOpcji;
			}
		}
		
		
		return maxLiczbaOpcji;
	}
	
	public List<PytanieToSzablon> findAllPytanieToSzablon() {
		return pytanieToSzablonRepository.findAll();
	}
	
	public PytanieToSzablon findPytanieToSzablonById(int id) {
		return pytanieToSzablonRepository.findOne(id);
	}
	
	public void usunPytanieToSzablonById(int id) {
		pytanieToSzablonRepository.delete(id);
	}

}
